home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 26 / Cream of the Crop 26.iso / program / ddj0897.zip / DYN401.ZIP / threads / semaphor.c < prev    next >
C/C++ Source or Header  |  1997-04-16  |  6KB  |  259 lines
  1.  
  2.  
  3. /*  Copyright (c) 1993-1996 Algorithms Corporation  */
  4. /*  All rights reserved.  */
  5.  
  6.  
  7.  
  8.  
  9. /*  This file automatically generated by dpp - do not edit  */
  10.  
  11. #define    DPP_STRATEGY    2
  12. #define    DPP_FASTWIDE    0
  13.  
  14.  
  15.  
  16. #line 18 "semaphor.d"
  17. #include <string.h> 
  18.  
  19. #define    CLASS    Semaphore_c
  20. #define    ivType    Semaphore_iv_t
  21.  
  22. #include "generics.h"
  23.  
  24. object    Semaphore_c;
  25.  
  26.  
  27. #line 28 "semaphor.c"
  28. typedef struct  _Semaphore_iv_t  {
  29.     object iObj;
  30.     char * iName;
  31.     int iCount;
  32.     int iMaximum;
  33.     object iWaiting_threads;
  34.     struct _Semaphore_iv_t * iNext;
  35. }    Semaphore_iv_t;
  36.  
  37.  
  38. #line 39 "semaphor.c"
  39. typedef struct  _Semaphore_cv_t  {
  40.     struct _Semaphore_iv_t * cMsl;
  41. }    Semaphore_cv_t;
  42.  
  43. static    Semaphore_cv_t    *Semaphore_cv;
  44.  
  45.  
  46.  
  47. #line 34 "semaphor.d"
  48. cmeth objrtn New(object self, char *name, int cnt, int mx)
  49. { 
  50.     object obj = oSuper(Semaphore_c, gNew, self)(self); 
  51.     ivType *iv = ivPtr(obj); 
  52.  
  53.     iv->iObj = obj; 
  54.     if (name) { 
  55.         iv->iName = Tnalloc(char, strlen(name)+1); 
  56.         strcpy(iv->iName, name); 
  57.     } 
  58.     iv->iCount = cnt; 
  59.     iv->iMaximum = mx; 
  60.     iv->iNext = Semaphore_cv->cMsl; 
  61.     Semaphore_cv->cMsl = iv; 
  62.     return obj; 
  63. } 
  64.  
  65. cmeth objrtn Semaphore_cm_gNew(object self)
  66. { 
  67.     return New(self, NULL, 1, 1); 
  68. } 
  69.  
  70. imeth int Semaphore_im_gWaitFor(object self)
  71. { Semaphore_iv_t *iv = GetIVs(Semaphore, self);
  72.     object ct; 
  73.  
  74.     INHIBIT_THREADER; 
  75.     if (!(ct = gFindStr(Thread, NULL))) { 
  76.         ENABLE_THREADER; 
  77.         return 0; 
  78.     } 
  79.     if (iv->iCount) { 
  80.         iv->iCount--; 
  81.         ENABLE_THREADER; 
  82.         return 0; 
  83.     } 
  84.     gWaitSemaphore(ct, self); 
  85.  
  86.     if (!iv->iWaiting_threads) 
  87.         iv->iWaiting_threads = gNew(LinkObject); 
  88.     gAddLast(iv->iWaiting_threads, ct); 
  89.     ENABLE_THREADER; 
  90.  
  91.     __dynace_yield(); 
  92.     return 0; 
  93. } 
  94.  
  95. imeth objrtn Release(object self, int cnt)
  96. { Semaphore_iv_t *iv = GetIVs(Semaphore, self);
  97.     object thread; 
  98.  
  99.     iv->iCount += cnt; 
  100.     if (iv->iCount > iv->iMaximum) 
  101.         iv->iCount = iv->iMaximum; 
  102.     INHIBIT_THREADER; 
  103.     while (iv->iCount && iv->iWaiting_threads && (thread = gFirst(iv->iWaiting_threads))) { 
  104.         gDisposeFirst(iv->iWaiting_threads); 
  105.         gReleaseSemaphore(thread); 
  106.         iv->iCount--; 
  107.     } 
  108.     ENABLE_THREADER; 
  109.     return self; 
  110. } 
  111.  
  112. imeth objrtn Semaphore_im_gDispose(object self)
  113. { Semaphore_iv_t *iv = GetIVs(Semaphore, self);
  114.     ivType *t, *p; 
  115.  
  116.     INHIBIT_THREADER; 
  117.     while (iv->iWaiting_threads && gFirst(iv->iWaiting_threads)) 
  118.         Release(self, iv->iMaximum); 
  119.     if (iv->iWaiting_threads) 
  120.         gDispose(iv->iWaiting_threads); 
  121.     if (iv->iName) 
  122.         free(iv->iName); 
  123.     for (p=NULL, t=Semaphore_cv->cMsl ; t ; p=t, t=t->iNext) 
  124.         if (t == iv) { 
  125.         if (p) 
  126.             p->iNext = t->iNext; 
  127.         else 
  128.             Semaphore_cv->cMsl = t->iNext; 
  129.         break; 
  130.     } 
  131.     oSuper(Semaphore_c, gDispose, self)(self); 
  132.     ENABLE_THREADER; 
  133.     return NULL; 
  134. } 
  135.  
  136. imeth objrtn Semaphore_im_gGCDispose(object self)
  137. { Semaphore_iv_t *iv = GetIVs(Semaphore, self);
  138.     ivType *t, *p; 
  139.  
  140.     INHIBIT_THREADER; 
  141.     if (iv->iWaiting_threads && gFirst(iv->iWaiting_threads)) { 
  142.         ENABLE_THREADER; 
  143.         return NULL; 
  144.     } 
  145.     if (iv->iName) 
  146.         free(iv->iName); 
  147.     for (p=NULL, t=Semaphore_cv->cMsl ; t ; p=t, t=t->iNext) 
  148.         if (t == iv) { 
  149.         if (p) 
  150.             p->iNext = t->iNext; 
  151.         else 
  152.             Semaphore_cv->cMsl = t->iNext; 
  153.         break; 
  154.     } 
  155.     oSuper(Semaphore_c, gDispose, self)(self); 
  156.     ENABLE_THREADER; 
  157.     return NULL; 
  158. } 
  159.  
  160. cmeth objrtn Semaphore_cm_gFindStr(object self, char *name)
  161. { 
  162.     ivType *iv; 
  163.  
  164.     USE(self); 
  165.     if (!name) 
  166.         return NULL; 
  167.     for (iv=Semaphore_cv->cMsl ; iv ; iv=iv->iNext) 
  168.         if (iv->iName && !strcmp(iv->iName, name)) 
  169.         return iv->iObj; 
  170.     return NULL; 
  171. } 
  172.  
  173. imeth int Semaphore_im_gCount(object self)
  174. { Semaphore_iv_t *iv = GetIVs(Semaphore, self);
  175.     return iv->iCount; 
  176. } 
  177.  
  178. imeth char * Semaphore_im_gName(object self)
  179. { Semaphore_iv_t *iv = GetIVs(Semaphore, self);
  180.     return iv->iName; 
  181. } 
  182.  
  183.  
  184.  
  185. imeth objrtn Semaphore_im_gRemoveWaits(object self, object thrd)
  186. { Semaphore_iv_t *iv = GetIVs(Semaphore, self);
  187.     object linkSequence, linkValue, thread; 
  188.  
  189.     if (!iv->iWaiting_threads) 
  190.         return self; 
  191.     INHIBIT_THREADER; 
  192.     linkSequence = gSequenceLinks(iv->iWaiting_threads); 
  193.     while (linkValue = gNext(linkSequence)) { 
  194.         thread = gValue(linkValue); 
  195.         if (thread == thrd) { 
  196.             gDispose(linkValue); 
  197.             break; 
  198.         } 
  199.     } 
  200.     if (linkValue) 
  201.         gDispose(linkSequence); 
  202.     ENABLE_THREADER; 
  203.     return self; 
  204. } 
  205.  
  206. imeth objrtn Semaphore_im_gCopy(object self)
  207. { 
  208.     return gShouldNotImplement(self, "Copy/DeepCopy"); 
  209. } 
  210.  
  211.  
  212. #line 213 "semaphor.c"
  213.  
  214. objrtn    Semaphore_initialize(void)
  215. {
  216.     static  CRITICALSECTION  cs;
  217.     static  int volatile once = 0;
  218.  
  219.     ENTERCRITICALSECTION(_CI_CS_);
  220.     if (!once) {
  221.         INITIALIZECRITICALSECTION(cs);
  222.         once = 1;
  223.     }
  224.     LEAVECRITICALSECTION(_CI_CS_);
  225.  
  226.     ENTERCRITICALSECTION(cs);
  227.  
  228.     if (Semaphore_c) {
  229.         LEAVECRITICALSECTION(cs);
  230.         return Semaphore_c;
  231.     }
  232.     INHIBIT_THREADER;
  233.     Semaphore_c = gNewClass(Class, "Semaphore", sizeof(Semaphore_iv_t), sizeof(Semaphore_cv_t), END);
  234.     cMethodFor(Semaphore, gNewSemaphore, New);
  235.     cMethodFor(Semaphore, gFindStr, Semaphore_cm_gFindStr);
  236.     cMethodFor(Semaphore, gNew, Semaphore_cm_gNew);
  237.     iMethodFor(Semaphore, gCount, Semaphore_im_gCount);
  238.     iMethodFor(Semaphore, gRemoveWaits, Semaphore_im_gRemoveWaits);
  239.     iMethodFor(Semaphore, gRelease, Release);
  240.     iMethodFor(Semaphore, gDispose, Semaphore_im_gDispose);
  241.     iMethodFor(Semaphore, gName, Semaphore_im_gName);
  242.     iMethodFor(Semaphore, gGCDispose, Semaphore_im_gGCDispose);
  243.     iMethodFor(Semaphore, gCopy, Semaphore_im_gCopy);
  244.     iMethodFor(Semaphore, gDeepDispose, Semaphore_im_gDispose);
  245.     iMethodFor(Semaphore, gDeepCopy, Semaphore_im_gCopy);
  246.     iMethodFor(Semaphore, gWaitFor, Semaphore_im_gWaitFor);
  247.  
  248.     Semaphore_cv = GetCVs(Semaphore);
  249.  
  250.     ENABLE_THREADER;
  251.  
  252.     LEAVECRITICALSECTION(cs);
  253.  
  254.     return Semaphore_c;
  255. }
  256.  
  257.  
  258.  
  259.